"""
这是__init__.py文件
当SubFunc作为包导入时,__init__.py文件会被执行
当在终端执行"python SubFunc"时,__init__.py文件不会被执行

本文件适用于存放适用于大部分项目的子方法
适用于特定项目的子方法,应放在对应项目文件夹中的 SubFunc.py 中
"""
import os
import random
from datetime import datetime,timedelta,date
from typing import Any, Callable, Union, List,Optional
import openpyxl
from openpyxl import load_workbook
from openpyxl.worksheet.worksheet import Worksheet
from openpyxl.utils import get_column_letter
from openpyxl import Workbook
import csv
import re
from decimal import Decimal
import unicodedata
import pandas

# 如果脚本被直接运行，__name__ 的值就是 "__main__"
# 该部分可以用作调试
if __name__ == "__main__":
    pass
else:
    print("MirrorFunc Was Imported")

def printAndExit(inV):
    if isinstance(inV, (dict, list)):
        for i in inV:
            print(i)
    else:
        print(inV)
    exit(1)

# 更自然的input方法
def inputNature(inPrompt: str = "请输入") -> str:
    """自然的输入方法，提示用户输入内容并返回输入的字符串。

    Args:
        内容 (str): 提示用户输入的字符串，默认为"请输入"。

    Returns:
        str: 用户输入的字符串。
    """
    print(inPrompt + ": ", end="")
    return input()


# 封装的输入数字
def inputInt(inPrompt: str) -> int:
    """封装的输入数字方法，提示用户输入数字并返回整数。

    Args:
        inPrompt (str): 提示用户输入的字符串。

    Returns:
        int: 用户输入的整数。
    """

    while True:
        try:
            output = int(inputNature(inPrompt))
            break
        except ValueError:
            print("输入的内容不是数字，请重新输入,或按[CTRL+C]退出")
    return output

def getFileName(inFilePath:str)-> str:
    """
    第一个形参必须由外部输入,否则将为包文件名
    """
    if inFilePath is None:
        print(f"MirrorFunc: GetFileName: 未传入路径,建议参数为__file__")
        return
    
    fullPath = os.path.realpath(inFilePath)
    # 提取文件名（含扩展名）
    fullName = os.path.basename(fullPath)
    return fullName

def getFileName_Human(inFilePath:str) -> str:
    return("<"+getFileName(inFilePath)+">")

def getFileName_NoSuffix(inFilePath:str)-> str:
    return os.path.splitext(getFileName(inFilePath))[0]

def autoMultiPrint(
    *inVs: Any,
    inTitle: Optional[str] = None,
    inLambda: Callable[[Any], Any] = lambda v: v,
) -> None:
    """通用的批量打印方法，可以打印多个变量及其相关信息。

    Args:
        *inVs (Any): 需要打印的变量。
        inTitle (str, optional): 每个变量的标题。默认为None。
        inLambda (Callable[[Any], Any], optional): 用于处理每个变量的函数。默认为lambda v: v。
    """
    counter = 0
    theSymbolBetweenTheKeyAndTheValue = ": "
    intervals = ", "

    for v in inVs:
        if counter != 0:
            print("  |  ", end="")
        counter += 1

        content1: str = (
            f"{inTitle}{theSymbolBetweenTheKeyAndTheValue}{inLambda(v)}"
            if inTitle is not None
            else ""
        )

        content2: str = f"{v}"

        print(
            f"{content1}{intervals}{content2}",
            end="",
        )
    print()


# 封装的查看变量的类型
def printType(*inVs: Any) -> None:
    """打印变量的类型。

    Args:
        *inVs (Any): 需要打印类型的变量。
    """
    autoMultiPrint(*inVs, inTitle="Type", inLambda=lambda v: type(v))


# 封装的查看变量的ID
def printID(*inVs: Any) -> None:
    """打印变量的ID。

    Args:
        *inVs (Any): 需要打印ID的变量。
    """
    autoMultiPrint(*inVs, inTitle="ID", inLambda=lambda v: id(v))


# 更自然的range
def range_Nature(inStart: int, inStop: int, inStep: int = 1) -> range:
    """生成一个自然范围，支持正向和反向。

    Args:
        inStart (int): 范围的起始值。
        inStop (int): 范围的结束值。
        inStep (int, optional): 步长,默认为1。

    Returns:
        range: 生成的范围对象。
    """
    offset = inStep
    if inStart > inStop:
        inStep = -inStep
        offset = -offset
    return range(inStart, inStop + offset, inStep)


# 封装的列表推导式
def listComprehension_Nature(
    inStartNum: int,
    inEndNum: int,
    inStep: int = 1,
    inLambda: Callable[[int], bool] = lambda x: True,
) -> list:
    """生成一个列表，支持条件过滤。

    Args:
        inStartNum (int): 列表的起始值。
        inEndNum (int): 列表的结束值。
        inStep (int, optional): 步长,默认为1。
        inLambda (Callable[[int], bool], optional): 过滤条件,默认为lambda x: True。

    Returns:
        list: 生成的列表。
    """
    return [i for i in range_Nature(inStartNum, inEndNum, inStep) if inLambda(i)]


# print列表
def printList(inList: list[Any]) -> None:
    """打印列表中的每个元素。
    Args:
        inList (list[Any]): 需要打印的列表。
    """
    for i in inList:
        print(i)


# 封装的随机数生成
def randomInt(下限: int, 上限: int) -> int:
    """生成一个在指定范围内的随机整数。

    Args:
        下限 (int): 随机数的下限。
        上限 (int): 随机数的上限。

    Returns:
        int: 生成的随机整数。
    """
    return int(random.random() * (上限 - 下限) + 下限)


# 封装的随机浮点数生成
def randomFloat(下限: float, 上限: float) -> float:
    """生成一个在指定范围内的随机浮点数。

    Args:
        下限 (float): 随机数的下限。
        上限 (float): 随机数的上限。

    Returns:
        float: 生成的随机浮点数。
    """
    return random.random() * (上限 - 下限) + 下限


# 清理控制台
def clearConsole() -> None:
    """
    清理控制台并打印当前时间。
    """
    os.system("clear")  # 用于清理控制台的代码
    print(f"<{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}> Console Cleaned\n")


def transpossList(inList: list) -> list:
    """转置二维列表。

    Args:
        inList (list): 需要转置的二维列表。

    Returns:
        list: 转置后的二维列表。
    """
    return list(map(list, zip(*inList)))


def generateDateRange(inStartDate:date,inEndDate:date):
    """
    生成指定日期范围内的日期列表。
    """
    # 确保起始日期小于结束日期
    (startDate, endDate)= (inStartDate, inEndDate) if inStartDate < inEndDate else (inEndDate, inStartDate)
    deltaDays=(endDate - startDate).days + 1
    return [startDate +timedelta(days=i) for i in range(deltaDays)]

def adjustDate_ByDay(inDate:date,inOfset:int) -> date:
    """
    改变指定日期的日数。
    """
    return inDate + timedelta(days=inOfset)

def getAllFilesPath(inDir: str) -> List[str]:
    """
    获取指定目录及其子目录下所有文件的完整路径列表

    Args:
        directory: 目标文件夹路径

    Returns:
        包含所有文件路径的列表，格式为绝对路径
        如果目录不存在返回空列表

    示例:
        >>> get_all_files('/path/to/dir')
        ['/path/to/dir/file1.txt', '/path/to/dir/subdir/file2.txt']
    """
    fileList = []
    
    # 验证目录是否存在
    if not os.path.isdir(inDir):
        print(f"Mirror Func: Get All Files Path: 警告: 目录不存在 -> {inDir}")
        return fileList

    #  打印目录文件数量
    printFileCount(inDir)

    try:
        # 使用os.walk遍历目录树
        for root, dirs, files in os.walk(inDir):
            for file in files:
                # 构建绝对路径
                full_path = os.path.abspath(os.path.join(root, file))
                fileList.append(full_path)
    except PermissionError as e:
        print(f"权限错误: {str(e)}")
    except Exception as e:
        print(f"发生未知错误: {str(e)}")
    
    return fileList



def deduplicateList(inList:list) -> list:
    """
    去除列表中的重复项，保留第一个出现的元素
    Args:
        inList (list): 输入列表
    Returns:
        list: 去重后的列表
    """
    seen = set()
    uniqueList = []
    for item in inList:
        itemTuple=tuple(item)
        if itemTuple not in seen:
            seen.add(itemTuple)
            uniqueList.append(list(itemTuple))
    return uniqueList




def printFileCount(inDir: str) -> Optional[int]:
    """
    统计指定目录及其子目录下的文件总数（不含子目录本身）

    参数:
        path (str): 目标目录路径

    输出:
        打印统计结果或错误信息
    """
    try:
        # 校验路径是否存在
        if not os.path.exists(inDir):
            print(f"MirrorFunc: printFileCount: 错误: 路径 '{inDir}' 不存在")
            return
        
        # 校验是否为目录
        if not os.path.isdir(inDir):
            print(f"MirrorFunc: printFileCount: 错误：'{inDir}' 不是目录")
            return
        
        # 使用 os.walk 递归遍历目录树
        totalFiles = 0
        for root, dirs, files in os.walk(inDir):
        
            totalFiles += len(files)  # 累加当前目录的文件数
        print(f"MirrorFunc: printFileCount: 目录<{inDir}>及其子目录中,共有 {totalFiles} 个文件")
        return totalFiles
    
    except PermissionError:
        print(f"错误：无权限访问 '{inDir}'")
    except Exception as e:
        print(f"发生未知错误：{str(e)}")



def getWorksheetRow(inWorksheet:Worksheet,inTargetLine=1):
    """
    获取指定工作表的指定行数据
    :param inWorksheet: openpyxl的Worksheet对象
    :param inTargetLine: 目标行号（从1开始）
    :return: 指定行的单元格对象列表
    :raises: IndexError 如果目标行号超出工作表范围
    """
    return inWorksheet[inTargetLine]



def cellsToList(inCells:list)->list:
    """
    将单元格对象列表转换为值列表
    """
    return [cell.value for cell in inCells]

def isEmptyList(inList:list)->bool:
    """
    检查列表是否为空或仅包含None值
    """
    return (not inList)

def calculateChineseLength(inStr: str) -> float:
    """计算所有全角字符占位"""
    # 正则表达式匹配全角字符的主要范围
    fullwidthPattern = re.compile(r'[\u3000-\u303f\uff00-\uffef]')
    
    # 遍历字符，检查是否为全角字符（补充正则未覆盖的边角情况）
    totalWidth:float = 0
    for char in inStr:
        if fullwidthPattern.match(char) or 'FULLWIDTH' in unicodedata.name(char, '') or unicodedata.east_asian_width(char) in ('F', 'W'):
            totalWidth += 1.9
        else:
            totalWidth += 1
    return totalWidth

def toPercentageStr(inValue, decimalPlaces=2)->str:
    """
    将数字转换为百分比字符串，并允许设置小数点位数
    :param inValue: 输入的数值
    :param decimalPlaces: 小数点后保留的位数，默认为2
    :return: 百分比字符串
    """
    return f"{inValue*100:.{decimalPlaces}f}%"

def getDay(inY,inM,inD) -> date:
    """
    获取指定年月日的日期对象
    :param inY: 年
    :param inM: 月
    :param inD: 日
    :return: 日期对象
    """
    return date(inY,inM,inD)

def dayOffset_Date(inDate: Union[date, datetime], inOffset: int) -> date:
    return inDate + timedelta(days=inOffset)

def dayOffset_Datetime(inDatetime: datetime, inOffset: int) -> datetime:
    return inDatetime + timedelta(days=inOffset)
    


def getMondayDate(inDate: date = date.today()) -> date:
    return inDate - timedelta(days=inDate.weekday())

def getFileSuffix_Lower(inFilePath: str) -> str:
    """
    注意后缀带点号

    获取文件路径的后缀名（小写）
    :param inFilePath: 文件路径
    :return: 后缀名（小写）
    """
    return os.path.splitext(inFilePath)[1].lower()

def copyFile(inFilePath, inDirPath, bufferSize=1024 * 1024):
    """
    将文件A复制到文件夹B(仅使用Python内置库)
    
    参数：
    - file_a_path: 源文件路径（需包含文件名）
    - folder_b_path: 目标文件夹路径
    - buffer_size: 缓冲区大小,默认1MB(优化大文件复制性能)
    """
    try:
        # 检查源文件是否存在
        if not os.path.isfile(inFilePath):
            raise FileNotFoundError(f"源文件 {inFilePath} 不存在")

        # 获取源文件名并构建目标路径
        filename = os.path.basename(inFilePath)
        dest_path = os.path.join(inDirPath, filename)

        # 创建目标文件夹（自动处理路径不存在的情况）
        os.makedirs(inDirPath, exist_ok=True)

        # 分块读写文件内容（避免内存溢出）
        with open(inFilePath, 'rb') as src_file:
            with open(dest_path, 'wb') as dest_file:
                while True:
                    data = src_file.read(bufferSize)
                    if not data:
                        break
                    dest_file.write(data)
        
        print(f"MirrorFunc: copyFile: 文件已成功复制到: {getFileName_Human(dest_path)}")
        return True
    
    except PermissionError:
        print(f"MirrorFunc: copyFile: 权限错误: 无法访问目标文件夹 {inDirPath}")
        return False
    except Exception as e:
        print(f"MirrorFunc: copyFile: 复制失败: {str(e)}")
        return False
    
class Xlsx:
    """
    Xlsx类,用于处理Excel文件

    推荐使用方法: from MirrorFunc import Xlsx as Mfxl
    """

    @staticmethod
    def getWorksheetTo2dList(inWs: Worksheet,inStartLine=1) -> list[list]:
        """将openpyxl工作表对象转换为二维列表
        
        :param ws: openpyxl的Worksheet对象
        :return: 二维列表，每个子列表代表一行数据
        """
        return [
            [cell_value for cell_value in row]  # 提取单行数据
            for row in inWs.iter_rows(values_only=True)  # 按行遍历且仅取值
        ]

    @staticmethod
    def loadWorkbookSafe(inFile:str,inReadOnly=False, inKeepVba=False,
                  inDataOnly=False, inKeepLinks=True, inRichText=False)->Union[Workbook,None]:
        
        """
        安全加载Excel工作簿,处理异常并返回工作簿对象或None
        :param inFile: Excel文件路径
        :param inReadOnly: 是否以只读模式打开
        :param inKeepVba: 是否保留VBA宏
        :param inDataOnly: 是否仅加载数据
        :param inKeepLinks: 是否保留链接
        :param inRichText: 是否保留富文本格式
        :return: Workbook对象或None
        """
        
        try:
            outputWb=openpyxl.load_workbook(inFile,
            read_only=inReadOnly, keep_vba=inKeepVba,
                    data_only=inDataOnly, keep_links=inKeepLinks, rich_text=inRichText)
        except Exception as e:
            outputWb = None
        return outputWb
    
    @staticmethod
    def dateToExcelSerial_Float(inDateStr:Union[str,None]) -> Union[float,None]:
        """
        将日期字符串转换为Excel格式的序列。
        """
        if inDateStr is None:
            return None
        
        try:
            theDate = datetime.strptime(inDateStr, "%Y-%m-%d")
            return (theDate - datetime(1899, 12, 30)).days + 1
        except ValueError:
            return None


    @staticmethod
    def dateToExcelSerial_Int(inDateStr:Union[str,None]) -> Union[int,None]:    
        """
        将日期字符串转换为Excel格式的序列。
        """
        floatResult = Xlsx.dateToExcelSerial_Float(inDateStr)
        if floatResult is None:
            raise ValueError("Invalid date string provided")
        return int(floatResult)
    
    @staticmethod
    def printWorksheet_ByRow(inWorkSheet:Worksheet) -> None:
        """
        按行打印工作表的所有单元格内容。

        Args:
            inWorkSheet (Worksheet): 需要打印的工作表对象。
        """
        for row in inWorkSheet.iter_rows(values_only=True):
            print(row)
        print()

    @staticmethod
    def printWorkheet_ByCol(inWorkSheet:Worksheet) -> None:
        """
        按列打印工作表的所有单元格内容。

        Args:
            inWorkSheet (Worksheet): 需要打印的工作表对象。
        """
        for col in inWorkSheet.iter_cols(values_only=True):
            print(col)
        print()

    @staticmethod
    def getColumnByLetter(inWorkSheet: Worksheet, inColumnName: str) -> List[Optional[str]]:
        """
        获取指定工作表中指定列的所有数据
        
        Args:
            worksheet: openpyxl的Worksheet对象
            column_name: 列名（如"A"或"BC")
            skip_header: 是否跳过首行表头(默认True)
        
        Returns:
            包含列数据的列表,空值保留为None
        
        Raises:
            ValueError: 当列名无效或超出范围时抛出
        """
        # 转换列名到列号（支持多字母如"BC"）
        def columnNameToIndex(name: str) -> int:
            """将Excel列名转换为列号（A=1, B=2, ..., BC=55）"""
            index = 0
            for char in name.upper():
                if not char.isalpha():
                    raise ValueError(f"无效列名字符: {char}")
                index = index * 26 + (ord(char) - ord('A') + 1)
            return index

        try:
            colIdx = columnNameToIndex(inColumnName)
        except ValueError as e:
            raise ValueError(f"无效列名格式: {inColumnName}") from e

        # 验证列是否存在
        if colIdx > inWorkSheet.max_column:
            raise ValueError(f"列 {inColumnName} 超出工作表范围（最大列：{inWorkSheet.max_column}）")

        # 收集列数据
        output = []
        for row in inWorkSheet.iter_rows(
            min_col=colIdx,
            max_col=colIdx,
            min_row=1,
            values_only=True,
        ):
            output.append(row[0])
        return output
    
    @staticmethod    
    def saveListToXlsx(inList: list, inSavePath: str, inFirstRow: Optional[list] = None):
        outputWb = Workbook()
        outputWs = outputWb.active

        if outputWs is None:
            print("SubFunc: List To Xlsx: The active worksheet is None. Ensure the workbook has at least one worksheet.")
            return None
        
        if inFirstRow is not None:
            outputWs.append(inFirstRow)

        for row in inList:
            outputWs.append(row)
        outputWb.save(inSavePath)
        Xlsx.autoAdjustColumnWidth_Cn(inSavePath)
        Xlsx.freezeFirstRow(inSavePath)

    @staticmethod
    def csvToXlsx(
        inCsvPath: str,
        inSaveXlsxPath: str,
        encoding: str = "utf-8",
        delimiter: str = ",",
        batch_size: int = 1000,
    ) -> None:
        """
        使用openpyxl实现CSV转XLSX

        参数说明:
            inCsvPath: 输入CSV文件路径
            inSaveXlsxPath: 输出XLSX文件路径
            encoding: CSV文件编码格式
            delimiter: CSV分隔符
            batch_size: 批量写入行数（性能优化参数）

        异常处理:
            FileNotFoundError: 输入文件不存在
            ValueError: CSV文件格式错误或为空
            PermissionError: 文件写入权限问题
            UnicodeDecodeError: 编码错误

        示例:
            >>> csvToXlsx('data.csv', 'output.xlsx', encoding='gbk')
        """
        try:
            # 验证输入文件存在
            if not os.path.isfile(inCsvPath):
                raise FileNotFoundError(f"输入文件不存在: {inCsvPath}")

            # 增强CSV文件格式验证
            if os.path.getsize(inCsvPath) == 0:
                raise ValueError(f"CSV文件为空: {inCsvPath}")

            # 创建工作簿
            wb = Workbook()
            ws = wb.active
            if ws is not None:
                ws.title = "Sheet1"
            else:
                raise ValueError("工作表创建失败,无法设置标题")

            # 读取CSV并写入Excel
            with open(inCsvPath, "r", encoding=encoding) as csvfile:
                reader = csv.reader(csvfile, delimiter=delimiter)

                # 检查CSV文件是否包含有效数据
                first_row = next(reader, None)
                if not first_row:
                    raise ValueError(f"CSV文件不包含有效数据: {inCsvPath}")

                # 写入表头
                ws.append(first_row)

                # 分块写入优化性能
                batch = []
                rowIdx = 0
                for rowIdx, row in enumerate(reader, 2):
                    batch.append(row)

                    # 每batch_size行写入一次
                    if len(batch) >= batch_size:
                        for b in batch:
                            ws.append(b)
                        batch = []
                        wb.save(inSaveXlsxPath)  # 定期保存防止内存溢出

                # 写入剩余数据
                if batch:
                    for b in batch:
                        ws.append(b)
                    wb.save(inSaveXlsxPath)

            print(f"MirrorFunc: csvToXlsx: {getFileName_Human(inCsvPath)}转换成功,共处理 {rowIdx}行数据")

        except UnicodeDecodeError as e:
            #编码错误直接跳过
            print(f"MirrorFunc: csvToXlsx: 已跳过{getFileName_Human(inCsvPath)},因编码不符")
        except ValueError as e:
            print(f"MirrorFunc: csvToXlsx: 错误: {str(e)}")
            print("MirrorFunc: csvToXlsx: 请检查CSV文件格式是否正确,确保文件非空且包含有效数据")
        except PermissionError as e:
            print(f"MirrorFunc: csvToXlsx: 权限错误: {str(e)}")
            print("MirrorFunc: csvToXlsx: 请关闭已打开的目标文件后重试")
        except Exception as e:
            print(f"MirrorFunc: csvToXlsx: 未知错误: {str(e)}")
    
    @staticmethod
    def autoAdjustColumnWidth_Cn(inFilePath:str):
        """
        自动调整Excel工作表的列宽,以适应中文字符
        
        参数:
        inFilePath: str, 输入文件的路径
        
        返回值:
        无返回值，直接修改文件
        """
        workbook = load_workbook(inFilePath)
        for sheet in workbook.worksheets:
            for index,col in enumerate(sheet.columns):
                max_length:float = 0
                column_letter = get_column_letter(index+1)
                for cell in col:
                    cell_value = str(cell.value) if cell.value is not None else ""
                    cell_length:float = calculateChineseLength(cell_value)
                    if cell_length > max_length:
                        max_length = cell_length
                sheet.column_dimensions[column_letter].width = max_length + 2  # 加2字符缓冲
        workbook.save(inFilePath)
    
    #获取sheet的第一行,并返回List
    @staticmethod
    def getWorksheetRow_ToList(inWorksheet:Worksheet,inTargetLine=1):
        """
        获取指定工作表的指定行数据并转换为列表
        :param inWorksheet: openpyxl的Worksheet对象
        :param inTargetLine: 目标行号（从1开始）
        :return: 列表，包含指定行的数据
        :raises: IndexError 如果目标行号超出工作表范围
        """
        if inWorksheet is None:
            return []

        firstRow_Cell = getWorksheetRow(inWorksheet=inWorksheet,inTargetLine=inTargetLine)
        firstRow_List=[cell.value for cell in firstRow_Cell]
        return firstRow_List
    
    @staticmethod
    def freezeFirstRow(inFilePath: str,inTargetCellReference="a2") -> None:
        """
        冻结Excel文件中每个工作表的第一行

        参数:
        inFilePath: str, 输入文件的路径

        返回值:
        无返回值，直接修改文件
        """
        wb = load_workbook(inFilePath)
        try:
            for sheet in wb.worksheets:
                # 冻结第一行
                sheet.freeze_panes = sheet[inTargetCellReference]
            wb.save(inFilePath)
        finally:
            wb.close()
    
    @staticmethod
    def creatSheet_AtEnd(inWb:Workbook,sheetName:str=None):
        """
        在Excel文件的最后位置插入一个新的Sheet
        """
        if not sheetName:
            sheetName=f"Sheet{len(inWb.sheetnames)+1}"
        
        inWb.create_sheet(sheetName)
    
    # @staticmethod
    # def creatPivotTableFromSheet(inXlsxPath:str,
    #                              inSourceSheetName:str,
    #                              inPivotColumn:list,
    #                              inValuesColumn:list,
    #                              inIndexColumn:list=None,
    #                              inAggfunc:str="sum",
    #                              inFillValue:float=0,
    #                              inOutputSheetName:str="透视表") -> None:
    #     """
    #     从现有 Excel Sheet 创建透视表
        
    #     参数:
    #         excel_path: Excel 文件路径
    #         source_sheet_name: 数据源所在的 Sheet 名称
    #         pivot_columns: 作为透视表列的字段列表
    #         values_column: 用于聚合的值字段
    #         index_columns: 作为透视表行的字段列表（默认为全部剩余字段）
    #         aggfunc: 聚合函数(默认 sum)
    #         fill_value: 缺失值填充(默认 0)
    #         output_sheet_name: 输出透视表的名称
    #     """

    #     df = pandas.read_excel(inXlsxPath, sheet_name=inSourceSheetName)
    #     if inIndexColumn is None:
    #         allColumns = set(df.columns)
    #         indexColumn = list(allColumns-set(inPivotColumn)-{inValuesColumn})
    #     else
    #         indexColumn=inIndexColumn
        
    #     pivotTable=df.pivot_table(
    #         values=inValuesColumn,
    #         index=indexColumn,
    #         columns=inPivotColumn,
    #         aggfunc=inAggfunc,
    #         fill_value=inFillValue,
    #     )
    #     ###未完成
        
